home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update26.zoo / util / diffs next >
Encoding:
Text File  |  1992-11-07  |  11.3 KB  |  407 lines
  1. *** 1.33    1992/10/11 02:39:24
  2. --- Changelog    1992/11/08 00:48:18
  3. ***************
  4. *** 377,379 ****
  5. --- 377,393 ----
  6.   cnm.c:: ++jrb
  7.       cleanup for hpux
  8.   ----------------------------- Patchlevel 32 --------------------------------
  9. + 
  10. + ld.c:: howard
  11. +     more fixes for baserel
  12. + 
  13. + ld.c:: ++jrb
  14. +     fixed BYTE_SWAP problem.
  15. + 
  16. + ld.c:: ++jrb
  17. +     more BYTE_SWAP fixes in the relocation stuff
  18. + 
  19. + toglclr.c: Thomas Schulze, ts@uni-paderborn.de
  20. +     add -fshare flag for sharex text (mint 0.96 and up).
  21. + 
  22. + ----------------------------- Patchlevel 33 --------------------------------
  23. *** 1.30    1992/10/11 02:39:24
  24. --- PatchLev.h    1992/11/08 00:48:20
  25. ***************
  26. *** 1,4 ****
  27. ! #define PatchLevel "32"
  28.   
  29.   /*
  30.    *    the Patch Level above is to identify the version
  31. --- 1,4 ----
  32. ! #define PatchLevel "33"
  33.   
  34.   /*
  35.    *    the Patch Level above is to identify the version
  36. *** 1.37    1992/10/11 02:39:24
  37. --- ld.c    1992/11/08 00:48:25
  38. ***************
  39. *** 2176,2181 ****
  40. --- 2176,2189 ----
  41.   
  42.         /* Grab the next entry.  */
  43.         p++;
  44. + 
  45. + #ifdef BYTE_SWAP
  46. + if (entry->superfile==NULL) {
  47. + p->n_un.n_strx = SWAP4(p->n_un.n_strx);    /* oochie wow-wow ??!!! -- ko */
  48. + p->n_desc      = SWAP2(p->n_desc);
  49. + p->n_value     = SWAP4(p->n_value); }
  50. + #endif /* BYTE_SWAP */
  51. + 
  52.         if (p->n_type != (N_UNDF | N_EXT))
  53.           {
  54.             fprintf (stderr, "%s: Warning symbol found in %s without external reference following.\n",
  55. ***************
  56. *** 2629,2634 ****
  57. --- 2637,2649 ----
  58.         if (index < 0 || index >= length_of_strings
  59.         || (index && *(sym_name_base + index - 1)))
  60.       fatal_with_file ("malformatted __.SYMDEF in ", entry);
  61. + 
  62. + #ifdef BYTE_SWAP
  63. +       if(sizeof(symdef_base[i].library_member_offset) == 4)
  64. +         symdef_base[i].library_member_offset = SWAP4(symdef_base[i].library_member_offset);
  65. +       else
  66. +         symdef_base[i].library_member_offset = SWAP2(symdef_base[i].library_member_offset);
  67. + #endif
  68.       }
  69.   
  70.     /* Search the symdef data for members to load.
  71. ***************
  72. *** 2663,2676 ****
  73.           register int j;
  74.           register int offset;
  75.           struct file_entry *subentry;
  76. - #ifdef BYTE_SWAP
  77. - if (sizeof(symdef_base[i].library_member_offset)==4)
  78. -   symdef_base[i].library_member_offset = SWAP4(symdef_base[i].library_member_offset);
  79. - else
  80. -   symdef_base[i].library_member_offset = SWAP2(symdef_base[i].library_member_offset);
  81. - #endif /* BYTE_SWAP */
  82.   
  83. ! offset = symdef_base[i].library_member_offset;
  84.   
  85.           /* Don't think carefully about any archive member
  86.              more than once in a given pass.  */
  87. --- 2678,2685 ----
  88.           register int j;
  89.           register int offset;
  90.           struct file_entry *subentry;
  91.   
  92. !                 offset = symdef_base[i].library_member_offset;
  93.   
  94.           /* Don't think carefully about any archive member
  95.              more than once in a given pass.  */
  96. ***************
  97. *** 4357,4371 ****
  98.        struct relocation_info *p;
  99.        struct file_entry *entry;
  100.   {
  101. !   register int symindex = RELOC_SYMBOL (p) * sizeof (struct nlist);
  102. !   register symbol *sp = ((symbol *)
  103. !             (((struct nlist *)
  104. !               (((char *)entry->symbols) + symindex))
  105. !              ->n_un.n_name));
  106.   
  107.     if (symindex >= entry->header.a_syms)
  108.       fatal_with_file ("relocation symbolnum out of range in ", entry);
  109.   
  110.   #ifdef N_INDR
  111.     /* Resolve indirection */
  112.     if ((sp->defined & ~N_EXT) == N_INDR)
  113. --- 4366,4382 ----
  114.        struct relocation_info *p;
  115.        struct file_entry *entry;
  116.   {
  117. !   register int symindex;
  118. !   register symbol *sp;
  119. ! 
  120. !   symindex = RELOC_SYMBOL (p) * sizeof (struct nlist);
  121.   
  122.     if (symindex >= entry->header.a_syms)
  123.       fatal_with_file ("relocation symbolnum out of range in ", entry);
  124.   
  125. +   sp = ((symbol *) (((struct nlist *) (((char *)entry->symbols) + symindex))
  126. +     ->n_un.n_name));
  127. + 
  128.   #ifdef N_INDR
  129.     /* Resolve indirection */
  130.     if ((sp->defined & ~N_EXT) == N_INDR)
  131. ***************
  132. *** 4373,4378 ****
  133. --- 4384,4409 ----
  134.   #endif
  135.     return sp;
  136.   }
  137. + 
  138. + static char *
  139. + retsymname (p, entry, addr)
  140. +     struct relocation_info *p;
  141. +     struct file_entry *entry;
  142. +     int addr;
  143. + {
  144. +   register struct nlist *n;
  145. + 
  146. +   if (RELOC_EXTERN_P(p)) {
  147. +     register symbol *sp = retsym(p, entry);
  148. +     return sp->name;
  149. +   }
  150. +   for (n=entry->symbols;
  151. +     n<(struct nlist *)((long)entry->symbols + entry->header.a_syms); n++)
  152. +     if (n->n_value == addr)
  153. +     return(entry->strings + n->n_un.n_strx);
  154. +   return "(static symbol)";
  155. + }
  156. + 
  157.   /* Relocate ENTRY's text or data section contents.
  158.      DATA is the address of the contents, in core.
  159.      DATA_SIZE is the length of the contents.
  160. ***************
  161. *** 4406,4412 ****
  162.         register int relocation = 0;
  163.         register int addr;
  164.         register unsigned int mask = 0;
  165. !       symbol *sp;
  166.   
  167.   #ifdef BYTE_SWAP    /* swap relocation info */
  168.   { /* BITFIELD ALERT BITFIELD ALERT */
  169. --- 4437,4443 ----
  170.         register int relocation = 0;
  171.         register int addr;
  172.         register unsigned int mask = 0;
  173. !       int oldreloc;
  174.   
  175.   #ifdef BYTE_SWAP    /* swap relocation info */
  176.   { /* BITFIELD ALERT BITFIELD ALERT */
  177. ***************
  178. *** 4429,4434 ****
  179. --- 4460,4466 ----
  180.   
  181.         if (RELOC_EXTERN_P(p))
  182.       {
  183. +             register symbol *sp;
  184.         sp = retsym(p, entry);
  185.   
  186.         /* If the symbol is undefined, leave it at zero.  */
  187. ***************
  188. *** 4471,4476 ****
  189. --- 4503,4509 ----
  190.         if (RELOC_PCREL_P(p))
  191.       relocation -= pc_relocation;
  192.   
  193. +       oldreloc = relocation;
  194.   #ifdef RELOC_ADD_EXTRA
  195.         relocation += RELOC_ADD_EXTRA(p);
  196.   #endif
  197. ***************
  198. *** 4496,4548 ****
  199.         break;
  200.   
  201.       case 1:
  202.         if (RELOC_MEMORY_ADD_P(p)) {
  203. !         if (RELOC_PCREL_P(p))
  204. !           relocation += mask & *(short *) (data + addr);
  205.           else
  206. !           relocation += mask & *(unsigned short *) (data + addr);
  207.         }
  208.         if (relocation > 32767 || relocation < -32768) {
  209. !         sp = retsym(p, entry);
  210. !         error ("relocation out of range for %s in %s",
  211. !             sp->name, entry->filename);
  212.           make_executable = 0;
  213.         }
  214. !       *(short *) (data + addr) &= ~mask;
  215. !       *(short *) (data + addr) |= relocation;
  216.         break;
  217.   
  218.       case 2:
  219.   #ifndef WORD_ALIGNED
  220. !       if (RELOC_MEMORY_ADD_P(p))
  221. !         relocation += mask & *(long *) (data + addr);
  222. !       *(long *) (data + addr) &= ~mask;
  223. !       *(long *) (data + addr) |= relocation;
  224.   #else
  225. !       {
  226. !       register unsigned long word = 0;
  227.   
  228. !       word |= (unsigned char)(data[addr]) << 24;
  229. !       word |= (unsigned char)(data[addr+1]) << 16;
  230. !       word |= (unsigned char)(data[addr+2]) << 8;
  231. !       word |= (unsigned char)(data[addr+3]);
  232.   
  233.         if (RELOC_MEMORY_ADD_P(p))
  234.           relocation += mask & word;
  235.         if (pure_text && relocation > text_size+text_start) {
  236. !         sp = retsym(p, entry);
  237.           error ("absolute reference to %s from pure-text in %s",
  238. !         sp->name, entry->filename);
  239.           make_executable = 0;    /* set exit code */
  240.         }
  241.         word &= ~mask;
  242.         word |= relocation;
  243. !       data[addr] = word >> 24;
  244. !       data[addr+1] = (word >> 16) & 0xff;
  245. !       data[addr+2] = (word >> 8) & 0xff;
  246. !       data[addr+3] = word & 0xff;
  247. !       }
  248.   #endif
  249.         break;
  250.   
  251.       default:
  252. --- 4529,4615 ----
  253.         break;
  254.   
  255.       case 1:
  256. +     {
  257. +       register int word;
  258.         if (RELOC_MEMORY_ADD_P(p)) {
  259. !         if (RELOC_PCREL_P(p)||RELOC_EXTERN_P(p))
  260. !           word = *(short *) (data + addr);
  261.           else
  262. !           word = *(unsigned short *) (data + addr);
  263. ! #ifdef BYTE_SWAP
  264. !         word = SWAP2(word);
  265. ! #endif
  266. !         relocation += mask & word;
  267.         }
  268.         if (relocation > 32767 || relocation < -32768) {
  269. !         if (!RELOC_EXTERN_P(p))
  270. !           if (!entry->strings) {
  271. !         entry->strings = (char *) alloca (entry->string_size);
  272. !         read_entry_strings (file_open (entry), entry);
  273. !           }
  274. !         error ("fatal error: relocation out of range for %s in %s",
  275. !         retsymname(p, entry, oldreloc+word), entry->filename);
  276.           make_executable = 0;
  277.         }
  278. !       word &= ~mask;
  279. !       word |= relocation;
  280. ! #ifdef BYTE_SWAP
  281. !       word = SWAP2(word);
  282. ! #endif
  283. !       *(short *) (data + addr) = word;
  284. !     }
  285.         break;
  286.   
  287.       case 2:
  288. +     {
  289. +       register unsigned long word;
  290.   #ifndef WORD_ALIGNED
  291. !       word = *(long *) (data + addr);
  292. ! #ifdef BYTE_SWAP
  293. !       word = SWAP4(word);
  294. ! #endif /* BYTE_SWAP */
  295.   #else
  296. !       word = ((unsigned long)(unsigned char)(data[addr])) << 24;
  297. !       word |= ((unsigned long)(unsigned char)(data[addr+1])) << 16;
  298. !       word |= ((unsigned long)(unsigned char)(data[addr+2])) << 8;
  299. !       word |= ((unsigned long)(unsigned char)(data[addr+3]));
  300. ! #ifdef BYTE_SWAP
  301. !     /* NOTE: We dont need to swap 4 because we are constructing
  302. !        the word here */
  303. ! #endif
  304.   
  305. ! #endif
  306.   
  307.         if (RELOC_MEMORY_ADD_P(p))
  308.           relocation += mask & word;
  309. + 
  310.         if (pure_text && relocation > text_size+text_start) {
  311. !         if (!RELOC_EXTERN_P(p))
  312. !           if (!entry->strings) {
  313. !         entry->strings = (char *) alloca (entry->string_size);
  314. !         read_entry_strings (file_open (entry), entry);
  315. !           }
  316.           error ("absolute reference to %s from pure-text in %s",
  317. !         retsymname(p, entry, relocation), entry->filename);
  318.           make_executable = 0;    /* set exit code */
  319.         }
  320.         word &= ~mask;
  321.         word |= relocation;
  322. ! #if (defined(BYTE_SWAP) && (!defined(WORD_ALIGNED)))
  323. !       word = SWAP4(word);
  324. ! #endif
  325. ! #ifndef WORD_ALIGNED
  326. !       *(long *) (data + addr) = word;
  327. ! #else
  328. !       data[addr+3] = word;
  329. !       word >>= 8;
  330. !       data[addr+2] = word;
  331. !       word >>= 8;
  332. !       data[addr+1] = word;
  333. !       word >>= 8;
  334. !       data[addr] = word;
  335.   #endif
  336. +     }
  337.         break;
  338.   
  339.       default:
  340. ***************
  341. *** 4562,4567 ****
  342. --- 4629,4635 ----
  343.   }
  344.   #endif /* BYTE_SWAP */
  345.       }
  346. +     entry->strings = 0;
  347.   }
  348.   
  349.   /* For relocatable_output only: write out the relocation,
  350. *** 1.3    1992/10/11 02:39:24
  351. --- toglclr.c    1992/11/08 00:48:30
  352. ***************
  353. *** 21,26 ****
  354. --- 21,30 ----
  355.    *    (bammi@cadence.com) to toggle the clear TPA above BSS flag
  356.    *    introduced with TOS 1.4. I extended it to also handle the additional
  357.    *    program flags introduced with the TOS versions for the STE and TT.
  358. +  *
  359. +  * 31-Oct-1992        Thomas Schulze
  360. +  *    Added code for MiNT 0.96 (and up) shared text feature. -fshare
  361. +  *    will switch this flag.
  362.    */
  363.   
  364.   #include <stdio.h>
  365. ***************
  366. *** 149,154 ****
  367. --- 153,162 ----
  368.          (int)((t & F_ALTALLOC) == F_ALTALLOC),
  369.          (int)((head.a_AZero2 & F_ALTALLOC) == F_ALTALLOC));
  370.   
  371. +     printf("%s: `shared text' bit was %d is now %d\n", fn,
  372. +         (int)((t & F_SHTEXT) == F_SHTEXT),
  373. +         (int)((head.a_AZero2 & F_SHTEXT) == F_SHTEXT));
  374. + 
  375.       return 0;
  376.   }
  377.   
  378. ***************
  379. *** 165,171 ****
  380.       fprintf(stderr, "usage: toglclr [options] file file .....\n\n");
  381.       fprintf(stderr, "options: -fload = toggle `fast load' bit\n");
  382.       fprintf(stderr, "         -frun  = toggle `load program into fast ram' bit\n");
  383. !     fprintf(stderr, "         -fram  = toggle `malloc from fast ram' bit\n\n");
  384.       fprintf(stderr, "without options the current state is reported.\n");
  385.       exit(1);
  386.       }
  387. --- 173,180 ----
  388.       fprintf(stderr, "usage: toglclr [options] file file .....\n\n");
  389.       fprintf(stderr, "options: -fload = toggle `fast load' bit\n");
  390.       fprintf(stderr, "         -frun  = toggle `load program into fast ram' bit\n");
  391. !     fprintf(stderr, "         -fram  = toggle `malloc from fast ram' bit\n");
  392. !     fprintf(stderr, "         -fshare= toggle `shared text' bit\n\n");
  393.       fprintf(stderr, "without options the current state is reported.\n");
  394.       exit(1);
  395.       }
  396. ***************
  397. *** 178,183 ****
  398. --- 187,194 ----
  399.           flags_to_toggle |= F_ALTLOAD;
  400.           if (!strcmp(*argv, "-fram"))
  401.           flags_to_toggle |= F_ALTALLOC;
  402. +     if (!strcmp(*argv, "-fshare"))
  403. +         flags_to_toggle |= F_SHTEXT;
  404.       --argc;
  405.       }
  406.   
  407.